import { UserRole, RoleDisplayNames, RolePermissions } from '../consts/role';
import { isValidRole, hasPermission} from '../helps/role'
import { IUser } from '../types';

/**
 * 角色管理工具类
 */
export class RoleManager {
  /**
   * 验证角色是否有效
   */
  static validateRole(role: string): { isValid: boolean; role?: UserRole; error?: string } {
    if (!role) {
      return { isValid: false, error: '角色不能为空' };
    }

    if (!isValidRole(role)) {
      return { 
        isValid: false, 
        error: `无效的角色: ${role}。` 
      };
    }

    return { isValid: true, role: role as UserRole };
  }

  /**
   * 获取角色的显示名称
   */
  static getRoleDisplayName(role: UserRole): string {
    return RoleDisplayNames[role] || '未知角色';
  }

  /**
   * 获取角色的所有权限
   */
  static getRolePermissions(role: UserRole): readonly string[] {
    return RolePermissions[role] || [];
  }

  /**
   * 是否有特定权限
   */
  static userHasPermission(user: IUser, permission: string): boolean {
    return hasPermission(user.role, permission);
  }

  /**
   * 是否是管理员
   */
  static isAdmin(user: IUser): boolean {
    return user.role === UserRole.ADMIN;
  }

  /**
   * 是否是普通用户
   */
  static isUser(user: IUser): boolean {
    return user.role === UserRole.USER;
  }

  /**
   * 比较两个角色的权限级别
   * @returns 1 如果 role1 权限更高, -1 如果 role2 权限更高, 0 如果相等
   */
  static compareRoles(role1: UserRole, role2: UserRole): number {
    const roleHierarchy = {
      [UserRole.ADMIN]: 2,
      [UserRole.USER]: 1
    };

    const level1 = roleHierarchy[role1] || 0;
    const level2 = roleHierarchy[role2] || 0;

    return level1 > level2 ? 1 : level1 < level2 ? -1 : 0;
  }

  /**
   * 获取角色统计信息
   */
  static getRoleStats(users: IUser[]): Record<UserRole, number> {
    const stats = {
      [UserRole.ADMIN]: 0,
      [UserRole.USER]: 0
    };

    users.forEach(user => {
      if (isValidRole(user.role)) {
        stats[user.role]++;
      }
    });

    return stats;
  }

  /**
   * 过滤指定角色的用户
   */
  static filterUsersByRole(users: IUser[], role: UserRole): IUser[] {
    return users.filter(user => user.role === role);
  }

  /**
   * 获取所有可用角色的信息
   */
  static getAllRolesInfo(): Array<{
    value: UserRole;
    displayName: string;
    permissions: readonly string[];
  }> {
    return Object.values(UserRole).map(role => ({
      value: role,
      displayName: RoleDisplayNames[role],
      permissions: RolePermissions[role]
    }));
  }

  /**
   * 检查角色升级是否被允许
   */
  static canUpgradeRole(currentRole: UserRole, targetRole: UserRole): boolean {
    // 只有管理员可以升级到管理员角色
    if (targetRole === UserRole.ADMIN) {
      return false; // 在实际应用中，这里应该检查操作者的权限
    }
    
    return this.compareRoles(targetRole, currentRole) >= 0;
  }
}
